Celestin Apprentice 7/Apprentice-Release7.iso/Environments/Clean 1.2.4/Clean Help/Clean Help.rsrc/STR#_10000.txt

Text File | 1997-06-20 | 7KB | 419 lines

Language Report" for an overview).

• Clean 1.2 is supported on several platforms (see "Concurrent Clean:



application;

indices out-of-range and when not enough memory is assigned to a Clean

their domain (e.g. dividing by zero), when arrays are accessed with

number of cases: when partial functions are called with arguments out of

objects being created run-time errors can only occur in a very limited

• Due to the strong typing of Clean and the obligation to initialize all



types;

for process creation, I/O and basic operations on objects of predefined

Clean includes a huge collection of predefined modules (standard libraries)

facility to implicitly and explicitly import definitions from other modules;

one defines implementation modules and definition modules; there is a

• Clean is a modular language allowing separate compilation of modules;



another processor;

its arguments being calculated by another process possibly executing on

handled automatically simply when one function demands the evaluation of

can be defined; the interprocess communication is synchronous and is

in parallel; arbitrary process topologies (for instance cyclic structures)

• Dynamic process creation is possible; processes can run interleaved or



procedure calls across a local area network;

communicating e.g. via (a)synchronous message passing and remote

can define distributed window based interactive Clean applications

• Sub-applications can be created on other machines which means that one



applications running on the same or even on a different host system;

passing) but also with other independently programmed (Clean or other)

like actions using shared state components, via asynchronous message

exchange information with each other (via files, via clipboard copy-paste

switching between menus is done automatically); sub-applications can

multi-finder (all low level event handling for updating windows and

between these sub-applications is handled in a similar way as under a

light-weight processes) inside one Clean application. Automatic switching

such that one can create several applications (sub-applications or

• Specifications of window based interactive applications can be combined



specified compactly and elegantly on a very high level of abstraction;

mouse, keyboard, timers and events raised by sub-applications) can be

interactive applications (and the handling of menus, dialogues, windows,

• Clean offers a sophisticated I/O library with which window based



offering direct access to file systems and operating systems;

non-functional world (to C but also to I/O systems like X-Windows)

transformation of state information, it enables efficient interfacing to the

of objects within a pure functional framework, it allows destructive

behaviour of programs; it can be used to incorporate destructive updates

with this uniqueness type system one can influence the time and space

system allowing a refined control over the single threaded use of objects;

system, a special extension of the Milner/Hindley type inferencing

• Clean's key feature is a polymorphic uniqueness type inferencing



characters, strings, lists, tuples, records, arrays and files;

• Clean offers the following predefined types: integers, reals, booleans,



overloaded use of functions and operators possible.

• Type classes and type constructor classes are provided to make



for existentially quantified types;

algebraic types, and synonym types extended with a restricted facility

Hindley 1969) including the common polymorphic types, abstract types,

well-known Milner/Hindley type inferencing scheme (Milner 1978;

• Clean is a strongly typed language based on an extension of the



in any of its arguments;

(recursive) data structure can be defined lazy as well as (partially) strict

can be defined lazy as well as (partially) strict in their arguments; any

into a strict language to obtain optimal time/space behaviour: functions

• Although Clean is by default a lazy language one can smoothly turn it



sharing of structures (cyclic structures as well) in the language;

with explicit graph rewriting semantics; one can explicitly define the

• Clean is a lazy, pure, higher order functional programming language





The most important features of Concurrent Clean are:






ñ1. Concurrent Clean version 1.2





For more background information we refer to the Bibliography.





ISBN 0-201-41663-8



1993



Addison-Wesley Publishing Company



Rinus Plasmeijer and Marko van Eekelen



Functional Programming and Parallel Graph Rewriting



explained in detail in the following textbook:

implementation on sequential and parallel machine architectures are

Functional programming languages, Concurrent Clean (0.8) and its





January 1997 (Draft Version)



University of Nijmegen



Rinus Plasmeijer and Marko van Eekelen



Reference Manual



- version 1.2 -



Concurrent Clean



Concurrent Clean 1.2 can be found in the following manual:

Concurrent Clean System. A description of the syntax and semantics of

This Help file complements version 1.2 of Concurrent Clean and the





developed at the University of Nijmegen.

programming environment for Concurrent Clean. Concurrent Clean is

Concurrent Clean Programming Development System is a special

sequential, parallel or distributed executing real world applications. The

functional programming language that can be used for the development of

Concurrent Clean 1.2 is a general purpose, higher order, pure and lazy








Print... from the File menu (see also the entry Help).





N.B. This Help file can be printed by choosing








Version 1.2 - January1997








Nijmegen - The Netherlands




University of Nijmegen




Computing Science Institute






© 1987-1997








»The Concurrent Clean Program Development System





H

G

F

E

D

C

B

A

@

?

>

=

<

;

:

9

8

7

6

5

4

3

2

1

0

/

.

-

,

+

*

)

(

'

&

%

$

#

"

!

























⌃

‚å•

‚áß

‚åò











































ñTable of Contents